home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / idlelib / CallTips.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  8KB  |  286 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. '''CallTips.py - An IDLE Extension to Jog Your Memory
  5.  
  6. Call Tips are floating windows which display function, class, and method
  7. parameter and docstring information when you type an opening parenthesis, and
  8. which disappear when you type a closing parenthesis.
  9.  
  10. Future plans include extending the functionality to include class attributes.
  11.  
  12. '''
  13. import sys
  14. import string
  15. import types
  16. import CallTipWindow
  17. import __main__
  18.  
  19. class CallTips:
  20.     menudefs = []
  21.     
  22.     def __init__(self, editwin = None):
  23.         if editwin is None:
  24.             self.editwin = None
  25.             return None
  26.         
  27.         self.editwin = editwin
  28.         self.text = editwin.text
  29.         self.calltip = None
  30.         self._make_calltip_window = self._make_tk_calltip_window
  31.  
  32.     
  33.     def close(self):
  34.         self._make_calltip_window = None
  35.  
  36.     
  37.     def _make_tk_calltip_window(self):
  38.         return CallTipWindow.CallTip(self.text)
  39.  
  40.     
  41.     def _remove_calltip_window(self):
  42.         if self.calltip:
  43.             self.calltip.hidetip()
  44.             self.calltip = None
  45.         
  46.  
  47.     
  48.     def paren_open_event(self, event):
  49.         self._remove_calltip_window()
  50.         name = self.get_name_at_cursor()
  51.         arg_text = self.fetch_tip(name)
  52.         if arg_text:
  53.             self.calltip_start = self.text.index('insert')
  54.             self.calltip = self._make_calltip_window()
  55.             self.calltip.showtip(arg_text)
  56.         
  57.         return ''
  58.  
  59.     
  60.     def paren_close_event(self, event):
  61.         self._remove_calltip_window()
  62.         return ''
  63.  
  64.     
  65.     def check_calltip_cancel_event(self, event):
  66.         if self.calltip:
  67.             if self.text.compare('insert', '<=', self.calltip_start) or self.text.compare('insert', '>', self.calltip_start + ' lineend'):
  68.                 self._remove_calltip_window()
  69.             
  70.         
  71.         return ''
  72.  
  73.     
  74.     def calltip_cancel_event(self, event):
  75.         self._remove_calltip_window()
  76.         return ''
  77.  
  78.     __IDCHARS = '._' + string.ascii_letters + string.digits
  79.     
  80.     def get_name_at_cursor(self):
  81.         idchars = self._CallTips__IDCHARS
  82.         str = self.text.get('insert linestart', 'insert')
  83.         i = len(str)
  84.         while i and str[i - 1] in idchars:
  85.             i -= 1
  86.         return str[i:]
  87.  
  88.     
  89.     def fetch_tip(self, name):
  90.         '''Return the argument list and docstring of a function or class
  91.  
  92.         If there is a Python subprocess, get the calltip there.  Otherwise,
  93.         either fetch_tip() is running in the subprocess itself or it was called
  94.         in an IDLE EditorWindow before any script had been run.
  95.  
  96.         The subprocess environment is that of the most recently run script.  If
  97.         two unrelated modules are being edited some calltips in the current
  98.         module may be inoperative if the module was not the last to run.
  99.  
  100.         '''
  101.         
  102.         try:
  103.             rpcclt = self.editwin.flist.pyshell.interp.rpcclt
  104.         except:
  105.             rpcclt = None
  106.  
  107.         if rpcclt:
  108.             return rpcclt.remotecall('exec', 'get_the_calltip', (name,), { })
  109.         else:
  110.             entity = self.get_entity(name)
  111.             return get_arg_text(entity)
  112.  
  113.     
  114.     def get_entity(self, name):
  115.         '''Lookup name in a namespace spanning sys.modules and __main.dict__'''
  116.         if name:
  117.             namespace = sys.modules.copy()
  118.             namespace.update(__main__.__dict__)
  119.             
  120.             try:
  121.                 return eval(name, namespace)
  122.             return None
  123.  
  124.         
  125.  
  126.  
  127.  
  128. def _find_constructor(class_ob):
  129.     
  130.     try:
  131.         return class_ob.__init__.im_func
  132.     except AttributeError:
  133.         for base in class_ob.__bases__:
  134.             rc = _find_constructor(base)
  135.             if rc is not None:
  136.                 return rc
  137.                 continue
  138.         
  139.  
  140.  
  141.  
  142. def get_arg_text(ob):
  143.     '''Get a string describing the arguments for the given object'''
  144.     argText = ''
  145.     if ob is not None:
  146.         argOffset = 0
  147.         if type(ob) == types.ClassType:
  148.             fob = _find_constructor(ob)
  149.             if fob is None:
  150.                 
  151.                 fob = lambda : pass
  152.             else:
  153.                 argOffset = 1
  154.         elif type(ob) == types.MethodType:
  155.             fob = ob.im_func
  156.             argOffset = 1
  157.         else:
  158.             fob = ob
  159.         if type(fob) in [
  160.             types.FunctionType,
  161.             types.LambdaType]:
  162.             
  163.             try:
  164.                 realArgs = fob.func_code.co_varnames[argOffset:fob.func_code.co_argcount]
  165.                 if not fob.func_defaults:
  166.                     pass
  167.                 defaults = []
  168.                 defaults = list(map((lambda name: '=%s' % name), defaults))
  169.                 defaults = [
  170.                     ''] * (len(realArgs) - len(defaults)) + defaults
  171.                 items = map((lambda arg, dflt: arg + dflt), realArgs, defaults)
  172.                 if fob.func_code.co_flags & 4:
  173.                     items.append('...')
  174.                 
  175.                 if fob.func_code.co_flags & 8:
  176.                     items.append('***')
  177.                 
  178.                 argText = ', '.join(items)
  179.                 argText = '(%s)' % argText
  180.  
  181.         
  182.         doc = getattr(ob, '__doc__', '')
  183.         if doc:
  184.             doc = doc.lstrip()
  185.             pos = doc.find('\n')
  186.             if pos < 0 or pos > 70:
  187.                 pos = 70
  188.             
  189.             if argText:
  190.                 argText += '\n'
  191.             
  192.             argText += doc[:pos]
  193.         
  194.     
  195.     return argText
  196.  
  197. if __name__ == '__main__':
  198.     
  199.     def t1():
  200.         '''()'''
  201.         pass
  202.  
  203.     
  204.     def t2(a, b = None):
  205.         '''(a, b=None)'''
  206.         pass
  207.  
  208.     
  209.     def t3(a, *args):
  210.         '''(a, ...)'''
  211.         pass
  212.  
  213.     
  214.     def t4(*args):
  215.         '''(...)'''
  216.         pass
  217.  
  218.     
  219.     def t5(a, *args):
  220.         '''(a, ...)'''
  221.         pass
  222.  
  223.     
  224.     def t6(a, b = None, *args, **kw):
  225.         '''(a, b=None, ..., ***)'''
  226.         pass
  227.  
  228.     
  229.     class TC:
  230.         '''(a=None, ...)'''
  231.         
  232.         def __init__(self, a = None, *b):
  233.             '''(a=None, ...)'''
  234.             pass
  235.  
  236.         
  237.         def t1(self):
  238.             '''()'''
  239.             pass
  240.  
  241.         
  242.         def t2(self, a, b = None):
  243.             '''(a, b=None)'''
  244.             pass
  245.  
  246.         
  247.         def t3(self, a, *args):
  248.             '''(a, ...)'''
  249.             pass
  250.  
  251.         
  252.         def t4(self, *args):
  253.             '''(...)'''
  254.             pass
  255.  
  256.         
  257.         def t5(self, a, *args):
  258.             '''(a, ...)'''
  259.             pass
  260.  
  261.         
  262.         def t6(self, a, b = None, *args, **kw):
  263.             '''(a, b=None, ..., ***)'''
  264.             pass
  265.  
  266.  
  267.     
  268.     def test(tests):
  269.         ct = CallTips()
  270.         failed = []
  271.         for t in tests:
  272.             expected = t.__doc__ + '\n' + t.__doc__
  273.             name = t.__name__
  274.             arg_text = ct.fetch_tip(name)
  275.             if arg_text != expected:
  276.                 failed.append(t)
  277.                 print '%s - expected %s, but got %s' % (t, expected, get_arg_text(entity))
  278.                 continue
  279.         
  280.         print '%d of %d tests failed' % (len(failed), len(tests))
  281.  
  282.     tc = TC()
  283.     tests = (t1, t2, t3, t4, t5, t6, TC, tc.t1, tc.t2, tc.t3, tc.t4, tc.t5, tc.t6)
  284.     test(tests)
  285.  
  286.